#include <iostream>
#include <vector>
#include <string>
#include <numeric>
#include <algorithm>

// 使用模板化IO优化，提高读写速度，适用于大数据量
void setup_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
}

/**
 * @brief 使用 Manacher 算法计算字符串中所有回文子串的数量
 * 
 * Manacher 算法是一个经典的线性时间算法，用于查找字符串中的最长回文子串。
 * 我们可以利用其计算出的半径数组，高效地统计所有回文子串的总数。
 * 
 * @param n 字符串 s 的长度
 * @param s 输入的字符串
 * @return long long 字符串 s 中所有回文子串的总个数
 */
long long count_palindromic_substrings(int n, const std::string& s) {
    long long count = 0;

    // Part 1: 计算所有奇数长度的回文子串
    // d1[i] 存储以 s[i] 为中心的最长回文串的半径。
    // 半径为 k 表示 s[i-k+1...i+k-1] 是回文串。
    // 以 s[i] 为中心的回文串数量即为其最长半径 d1[i]。
    std::vector<int> d1(n);
    // [l, r] 维护当前找到的所有回文串中，右端点最靠右的那个回文串的边界
    for (int i = 0, l = 0, r = -1; i < n; ++i) {
        // 确定初始半径 k：
        // 如果 i 在 [l, r] 右边，只能从1开始暴力匹配
        // 否则，可以利用已有的信息。i 关于 (l+r)/2 的对称点是 l+r-i。
        // d1[l+r-i] 是对称点的半径，但不能超过当前右边界 r。
        int k = (i > r) ? 1 : std::min(d1[l + r - i], r - i + 1);
        // 从半径 k 开始继续扩展
        while (i - k >= 0 && i + k < n && s[i - k] == s[i + k]) {
            k++;
        }
        d1[i] = k;
        // 如果以 i 为中心的回文串右边界超过了 r, 更新 [l, r]
        if (i + k - 1 > r) {
            l = i - k + 1;
            r = i + k - 1;
        }
    }

    // Part 2: 计算所有偶数长度的回文子串
    // d2[i] 存储以 s[i-1] 和 s[i] 之间为中心的最长回文串的半长。
    // 半长为 k 表示 s[i-k...i+k-1] 是回文串。
    // 以 (i-1, i) 为中心的回文串数量即为其最长半长 d2[i]。
    std::vector<int> d2(n);
    for (int i = 0, l = 0, r = -1; i < n; ++i) {
        // 确定初始半长 k
        int k = (i > r) ? 0 : std::min(d2[l + r - i + 1], r - i + 1);
        // 从半长 k 开始继续扩展
        while (i - k - 1 >= 0 && i + k < n && s[i - k - 1] == s[i + k]) {
            k++;
        }
        d2[i] = k;
        // 更新 [l, r]
        if (i + k - 1 > r) {
            l = i - k;
            r = i + k - 1;
        }
    }

    // 所有回文子串总数 = 奇数长度回文串总数 + 偶数长度回文串总数
    // 使用 std::accumulate 高效求和
    count = std::accumulate(d1.begin(), d1.end(), 0LL);
    count += std::accumulate(d2.begin(), d2.end(), 0LL);

    return count;
}


int main() {
    setup_io();

    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;

    // 步骤1: 计算总的操作方案数
    // 对于每个 l from 1 to n, r可以取 l, l+1, ..., n，共 n-l+1 种选择。
    // 总数为 n + (n-1) + ... + 1 = n*(n+1)/2。
    long long total_choices = (long long)n * (n + 1) / 2;

    // 步骤2: 计算所有回文子串的数量 P
    long long palindromic_substrings_count = count_palindromic_substrings(n, s);

    // 步骤3: 根据核心公式计算最终答案
    // 总的不同字符串数 = (非回文翻转产生的不同字符串数) + (回文翻转产生的不同字符串数)
    // 非回文翻转有 (total_choices - P) 种，每种产生一个独一无二的字符串。
    // 回文翻转有 P 种，全部只产生原字符串 s 这一个结果。
    // 所以总数为 (total_choices - P) + 1。
    long long distinct_strings_count = total_choices - palindromic_substrings_count + 1;
    
    std::cout << distinct_strings_count << std::endl;

    return 0;
}
